home *** CD-ROM | disk | FTP | other *** search
/ No Fragments Archive 12: Textmags & Docs / nf_archive_12.iso / MAGS / SOURCES / ATARI_SRC.ZIP / atari source / HDX_BACK / HDX401.ATB / BSL.C < prev    next >
Encoding:
C/C++ Source or Header  |  2001-02-09  |  21.5 KB  |  776 lines
  1.  /*
  2.  * BSL.C
  3.  *
  4.  *     Functions to manipulate the Bad Sector List.
  5.  *
  6.  * 25-Nov-87    ml.    Started this mess.
  7.  * 04-Dec-87    ml.    Hmmm, looks OK.
  8.  * 11-Dec-87    ml.    Added bsl2fat().
  9.  * 14-Dec-87    ml.    Structure of BSL is changed (_again_!).
  10.  *            Now, first entry in BSL contains number VENDOR
  11.  *            entries.  First byte of 2nd entry is the checksum
  12.  *            byte, while 2nd and 3rd bytes are reserved for 
  13.  *            future use.
  14.  * 08-Nov-87    jye. change or add codes so that can be used for MS-DOS
  15.  *
  16.  */
  17.  
  18. #include "obdefs.h"
  19. #include "osbind.h"
  20. #include "mydefs.h"
  21. #include "part.h"
  22. #include "bsl.h" 
  23. #include "hdx.h"
  24. #include "addr.h" 
  25. #include "myerror.h" 
  26.  
  27. /* Globals */
  28. BYTE *bsl;            /* bad sector list */
  29. long bslsiz;            /* num sectors BSL occupies */
  30. SECTOR badbuf[WARNBADSECTS];    /* bad sectors buffer */
  31. extern int tformat;        /* 1: called by Format */
  32. extern long ratio;
  33.  
  34.  
  35. /*
  36.  *  Get size of the Bad Sector List (in sectors)
  37.  *    Input:
  38.  *        pdev - physical unit BSL belongs to.
  39.  *    Return:
  40.  *        number of sectors BSL occupies.
  41.  */
  42. long 
  43. gbslsiz(pdev) 
  44. int pdev;    /* physical device number */
  45. {
  46.     char bs[512];    /* boot sector image */
  47.     UWORD  ret;
  48.     
  49.        if ((ret = getroot(pdev, bs, (SECTOR)0)) != 0) {
  50.            if (tsterr(ret) == OK)
  51.             return MDMERR;
  52.         else return ERROR;
  53.        }
  54.        if (((RSECT *)(bs + 0x200 - sizeof(RSECT)))->bsl_st != STBSL)
  55.            return 0L;
  56.        return(((RSECT *)(bs + 0x200 - sizeof(RSECT)))->bsl_cnt);
  57. }
  58.  
  59.  
  60. /*
  61.  *  Set BSL parameters (starting sector and size of BSL) into
  62.  *  root sector image.
  63.  *    Input:
  64.  *        image - root sector image.
  65.  */
  66.  
  67. sbslparm(image)
  68. char *image;
  69. {
  70.     ((RSECT *)(image + 0x200 - sizeof(RSECT)))->bsl_st = STBSL;
  71.     ((RSECT *)(image + 0x200 - sizeof(RSECT)))->bsl_cnt = bslsiz;
  72. }
  73.  
  74.  
  75. /* 
  76.  *  Create a BSL in memory.
  77.  *    Input:
  78.  *        pdev - physical unit BSL will belong to.
  79.  *        type - kind of BSL to be created. NEW or EXPAND.
  80.  *        nents - number of VENDOR entries BSL should hold.
  81.  *    Output:
  82.  *        bsl - pointer to the BSL. (in bsl.h)
  83.  *    Return:
  84.  *        OK - everything is fine.
  85.  *        ERROR - anything is wrong.
  86.  *    Comment:
  87.  *        "NEW" means to create a totally new BSL.
  88.  *        "EXPAND" means to expand an existing BSL.
  89.  */
  90. creabsl(pdev, type, nents)
  91. int  pdev;    /* physical unit number */
  92. int  type;    /* kind of BSL to be created */
  93. long  nents;    /* num VENDOR entries in BSL */
  94. {
  95.     BYTE *newbsl;  /* BSL just created */
  96.     long l, size;  /* l - index into BSL;  size - size of BSL in bytes */ 
  97.     long start;       /* where to start initializing entries to zeroes */
  98.     long nument();
  99.  
  100.     if (nents == 0) {    /* no VENDOR entries specified */
  101.         size = 512L;    /* default size of BSL to 1 sector */
  102.     } else {       /* num VENDOR entries is specified */
  103.         /*------------------------------------------------------*/
  104.         /* Calculate length of BSL in bytes.            */
  105.         /* Have to add space for reserved entries and USER list    */
  106.         /* (note: (+1) to round up)                */
  107.         /*------------------------------------------------------*/
  108.     size = (((nents + RENT + WARNBADSECTS)/EPS) + 1) * 512L;
  109.     }
  110.     
  111.     /* allocate enough memory for new BSL */
  112.     if ((newbsl = (BYTE *)mymalloc((int)size)) <= 0)
  113.         return err(nomemory);
  114.     
  115.     if (type == NEW) {    /* a new BSL */
  116.         start = 0;    /* start at 0th entry, i.e. init whole BSL to 0s */
  117.     }    
  118.     else {        /* expand the BSL */
  119.         /* start init to 0s after VENDOR list */
  120.     start = (nument(VENDOR) + RENT) * BPE;
  121.     
  122.         /* copy original BSL into this expanded memory */
  123.         for (l = 0; l < start; l++)
  124.             newbsl[l] = bsl[l];
  125.     }
  126.         
  127.             
  128.     /* free up old BSL */
  129.     if (bsl > 0) free(bsl);
  130.     bsl = newbsl;
  131.     
  132.     /* init BSL to zeroes beginning at 'start'th entry */
  133.     for (l = start; l < size; l++)
  134.         bsl[l] = 0;
  135.         
  136.     /* install BSL info */
  137.     bslsiz = size/512;    /* current num sectors BSL occupies */
  138.     put3bytes(bsl, nents);  /* num VENDOR entries */
  139.     mkmagic();    /* make the BSL checks sum to BSLMAGIC byte-wise */
  140.                           
  141.     return OK;
  142. }
  143.  
  144.  
  145. /*
  146.  *  Read the BSL into memory.
  147.  *    Input:
  148.  *        pdev - physical unit that contains the BSL.
  149.  *    Output:
  150.  *        bsl - pointer to the BSL.  (in bsl.h)
  151.  *    Return:
  152.  *        OK - everything is fine.
  153.  *        INVALID - BSL doesn't checksum correctly.
  154.  *        ERROR - can't read BSL.
  155.  */
  156. rdbsl(pdev)
  157. int pdev;    /* physical unit to read from */
  158. {
  159.     int ret;
  160.     
  161.     if ((ret = rdsects(pdev, (UWORD)bslsiz, bsl, (SECTOR)STBSL)) != 0) {
  162.         if (tsterr(ret) != OK) {
  163.             if (tformat == FALSE)
  164.             err(bslread);
  165.         }
  166.     return ERROR;
  167.     }
  168.         
  169.     return(sumbsl());    /* Checksum BSL and return */
  170. }
  171.  
  172.  
  173. /*
  174.  *  Count number of entries in the requested portion of BSL.
  175.  *    Input:
  176.  *        portion - portion of BSL.  MEDIA, VENDOR, USER or UNUSED.
  177.  *    Return:
  178.  *        Number of entries of the requested portion.
  179.  *    Comments:
  180.  *        There are 3 bytes per entry (BPE), and the first 2 entries
  181.  *    are reserved (RENT) for BSL info.
  182.  */
  183. long
  184. nument(portion)
  185. int portion;        /* portion of BSL to be counted */
  186. {
  187.     long  vdr, usr;        /* num ent in VENDOR list, num ent in USER list */
  188.     long  nbytes, offset;   /* BSL's len in bytes, index into BSL */
  189.     long  get3bytes();
  190.     
  191.     /* 2nd entry in BSL contains num entries in VENDOR list */
  192.     vdr = get3bytes(bsl);
  193.     
  194.     if (portion == VENDOR)  return (vdr);
  195.     
  196.     nbytes = bslsiz*512;    /* num bytes in BSL */
  197.     
  198.     /* num bytes available for valid entries */
  199.     /* (need this because nbytes may not be divisible by BPE) */
  200.     nbytes -= (nbytes % BPE);
  201.     
  202.     /* find out num entries in USER list */
  203.     usr = 0;
  204.     for (offset = (RENT+vdr)*BPE;  /* index into beginning of USER list */
  205.          (offset < nbytes)       /* while not at end of BSL */
  206.      && get3bytes(bsl+offset); /* and it's a used entry */
  207.          offset += BPE)           /* increment index */
  208.         usr++;        /* increment num entries for USER list */
  209.          
  210.     if (portion == USER)
  211.         return (usr);        /* num entries in USER list */
  212.         
  213.     if (portion == MEDIA)
  214.         return (vdr+usr);    /* num entries in MEDIA list */     
  215.         
  216.     /* portion == UNUSED */
  217.     return ((nbytes/BPE)-RENT-vdr-usr);
  218. }
  219.  
  220.  
  221. /*
  222.  *  Write the BSL into the disk.
  223.  *    Input:
  224.  *        pdev - physical unit number BSL belongs to.
  225.  *        bsl - pointer to buffer containing the BSL. (in bsl.h)
  226.  *    Return:
  227.  *        OK - everything is fine.
  228.  *        ERROR - can't write BSL.
  229.  */
  230. wrbsl(pdev)
  231. int pdev;    /* physical unit number */
  232. {
  233.     int ret;            /* return code */
  234.  
  235.     *((int *)(bsl + 0x4)) = 0;        /* set the 4th & 5th byte to 0 in BSL */
  236.     mkmagic();
  237.     if ((ret = wrsects(pdev, (UWORD)bslsiz, bsl, (SECTOR)STBSL)) != 0) {
  238.         if (tsterr(ret) != OK)
  239.             err(bslwrite);
  240.         return ERROR;
  241.     }
  242.  
  243.     return OK;
  244. } 
  245.  
  246.  
  247. /*
  248.  *  Sort the BSL in memory in ascending order.
  249.  *    Input:
  250.  *        entries - number of used entries in BSL
  251.  *        bsl - pointer to the BSL. (in bsl.h)
  252.  *    Output:
  253.  *        a sorted bsl.
  254.  *    Algorithm:
  255.  *        Bubble sort.
  256.  *    Comments:
  257.  *        The reserved entries won't be sorted.
  258.  */
  259. sortbsl(entries)
  260. long  entries;    /* num entries in BSL */
  261. {
  262.     long  i, e1, e2;
  263.     long  start;    /* beginning byte of entries in BSL */
  264.     long  end;        /* tail byte of BSL */
  265.     int   change;    /* signal if changes have been made in current pass */
  266.     long  get3bytes();
  267.     
  268.     if (entries == 0L || entries == 1L)    /* BSL is empty */
  269.         return;
  270.             
  271.     change = 1;        /* assume list is not in order */
  272.     start = RENT*BPE;    /* beginning of entries in BSL */
  273.     end = entries * BPE;
  274.     while (1) {
  275.         if (change == 0)    /* if no changes made, DONE --> HOME */
  276.         return;
  277.         
  278.         change = 0;    /* assume list is in order */
  279.         for (i = start; i <= end; i += BPE) {
  280.             e1 = get3bytes(bsl+i);
  281.             e2 = get3bytes(bsl+i+BPE);
  282.             if (e1 > e2) {            /* switch if out of order */
  283.                 put3bytes(bsl+i, e2);
  284.                 put3bytes(bsl+i+BPE, e1);
  285.                 change = 1;
  286.             }
  287.         }
  288.         end -= BPE;
  289.     }
  290. }
  291.  
  292.  
  293. /*
  294.  *  Search through a sorted BSL for a given sector number.
  295.  *    Input:
  296.  *        sect - sector number searching for.
  297.  *        entries - number of used entries in the BSL.
  298.  *    Return:
  299.  *        YES - if given sector is found.
  300.  *        NO - if given sector is not found.
  301.  *    Algorithm:
  302.  *        Binary Search.
  303.  */
  304. srchbsl(sect, entries)
  305. SECTOR  sect;    /* sector searching for */
  306. long  entries;    /* num used entries in BSL */
  307. {
  308.     long  start, mid, end; /* start, middle and end indices into list */
  309.     SECTOR  temp;       /* sector number in middle of list */
  310.     long  get3bytes();
  311.  
  312.     start = RENT;        /* start after reserved entries */
  313.     end = entries+RENT-1;    /* end of BSL */ 
  314.     
  315.     while (1) {
  316.          mid = (start + end) / 2;        /* middle entry in list */
  317.         temp = get3bytes(bsl+(mid*BPE));    /* sector num at mid entry */
  318.         
  319.         if (sect == temp)    /* given sector == sector at mid entry */
  320.             return YES;        /* given sector found in list */
  321.         else if (sect < temp)    /* given sector < sector at mid entry */
  322.             end = mid - 1;    /* limit search to smaller sector num */
  323.         else            /* given sector > sector at mid entry */
  324.             start = mid + 1;    /* limit search to larger sector num */
  325.             
  326.         if (end < start)    /* list is exhausted */
  327.             return NO;        /* can't find given sector */    
  328.     }
  329. }
  330.  
  331.  
  332. /*
  333.  *  Checksum (byte-wise) the BSL.
  334.  *    Input:
  335.  *        bsl - pointer to the BSL.  (in bsl.h)
  336.  *    Return:
  337.  *        OK - BSL checksum to BSLMAGIC (0xa5).
  338.  *        INVALID - BSL does not checksum to BSLMAGIC.
  339.  */
  340. sumbsl()
  341. {
  342.     register BYTE sum;    /* byte-wise sum of BSL */
  343.     long i;        /* index into BSL */
  344.     long length;    /* length of BSL in bytes */
  345.  
  346.     length = bslsiz*512;    /* length of entire BSL */
  347.     sum = 0;    /* initialize the sum */
  348.     
  349.     /* Sum up values in the BSL by byte */
  350.     for (i = 0; i < length; i++) {
  351.         sum += bsl[i];
  352.     }
  353.     if (sum != BSLMAGIC) {    /* doesn't checksum correctly */
  354.         return INVALID;
  355.     }
  356.     return OK;    /* checksum correctly */
  357. }
  358.  
  359.  
  360. /*
  361.  *  Make the BSL checks sum to BSLMAGIC.
  362.  */
  363. mkmagic()
  364. {
  365.     register BYTE diff;    /* difference to make BSL checks sum correctly */
  366.     long i;        /* index into BSL */
  367.     long len;        /* length of BSL in bytes */
  368.     
  369.     len = bslsiz*512;    /* length of entire BSl */
  370.     diff = BSLMAGIC;    /* initialize the difference */
  371.     
  372.     /* find out what number would make BSL checks sum to BSLMAGIC */
  373.     for (i = 0; i < len; i++) {
  374.         diff -= bsl[i];
  375.     }
  376.     
  377.     /* add that difference to checksum byte (1st byte of 2nd entry of BSL) */
  378.     bsl[BPE] += diff;
  379. }
  380.  
  381.  
  382. /*
  383.  *  Add bad sectors found to the Bad Sector List.
  384.  *    Input:
  385.  *        pdev - physical unit BSL belongs to.
  386.  *        portion - portion of BSL to add to.  VENDOR or USER.
  387.  *        nbad - number of bad sectors to be added.
  388.  *    Return:
  389.  *        toadd - number of new bad sectors added to the BSL.
  390.  *        USRFULL - user part of the BSL is filled up.
  391.  *        NOMEM - not enough memory for add buffer or BSL.
  392.  *        ERROR - something is wrong.
  393.  *    Comment:
  394.  *        The entry will be added only if it is not already on the
  395.  *    bad sector list.  Binary search is performed to guarantee this.
  396.  *        If the VENDOR list is full, this routine will take care
  397.  *    of the expansion of the list also.
  398.  */
  399. addbsl(pdev, portion, nbad) 
  400. int pdev;        /* physical unit number */
  401. int portion;        /* portion of BSL */
  402. int nbad;        /* num of bad sectors to be added */
  403. {
  404.     long  entries;    /* num entries to be retained in BSL */
  405.     long  empty;    /* num empty slots available for adding entries */
  406.     long  end;        /* address of end of BSL */
  407.     int  i, toadd;    /* index to badbuf, num of bad sectors to be added */
  408.     int  ret = 0;    /* return code */
  409.     SECTOR *addbuf;    /* bad sectors to be added to BSL */
  410.     long  nument();
  411.     
  412.     /* Allocate memory for sector numbers of bad sectors to be added */
  413.     if ((addbuf = (SECTOR *)mymalloc(nbad*4)) <= 0) {
  414.         err(nomemory);
  415.         return NOMEM;
  416.     }
  417.     
  418.     if (portion == VENDOR) {    /* adding to VENDOR list */
  419.         entries = nument(VENDOR);   /* only keep the VENDOR list */
  420.         empty = 0;            /* there's no unused slot for VENDOR ent */
  421.     } else {            /* adding to USER list */
  422.         entries = nument(MEDIA);    /* keep entire list */
  423.         empty = nument(UNUSED);     /* slots left unused */
  424.     }
  425.     sortbsl(entries);        /* sort BSL in ascending order */
  426.     toadd = 0;            /* none is to be added to BSL yet */
  427.  
  428.     /* For all bad sectors found, search for them in the current BSL.
  429.        Add them to the list only when they are not already recorded.  */    
  430.     if (entries) {    /* only search if BSL is not empty */
  431.     for (i = 0; i < nbad; i++) {
  432.         if (srchbsl(badbuf[i], entries) == NO) {
  433.         addbuf[toadd] = badbuf[i];
  434.         toadd++;
  435.         }
  436.         }
  437.     } else {  /* add in all bad sectors found */
  438.     for (i = 0; i < nbad; i++)
  439.         addbuf[i] = badbuf[i];
  440.         toadd = nbad;
  441.     }
  442.     
  443.     /* All bad sectors found have been recorded.  Nothing is added to BSL */
  444.     if (toadd == 0) {
  445.         if (portion == USER && (ret = rdbsl(pdev)) != OK) {
  446.             if (ret == INVALID)
  447.                 err(cruptbsl);
  448.         goto togo;
  449.     }
  450.         ret = toadd;
  451.     }
  452.     
  453.     /*------------------------------------------------------------------*/
  454.     /* Check if there are enough empty slots for new entries.  If not,    */
  455.     /* determine what kind of entries we are adding, VENDOR or USER.    */    
  456.     /* Expand the BSL if we are adding to VENDOR list.  Give warning    */
  457.     /* if we are adding to USER list.                          */
  458.     /*------------------------------------------------------------------*/
  459.     if (toadd > empty) {
  460.         if (portion == VENDOR) {    /* this only happens at format time */
  461.         /* expanded BSL should hold (entries + toadd) VENDOR entries */
  462.         if (creabsl(pdev, EXPAND, entries+toadd) != OK)
  463.             goto togo;
  464.         } else {            /* We are adding to USER list */
  465.             err(manybad);
  466.             toadd = empty;    /* num ent to add = empty slots available */
  467.         }
  468.     }
  469.     
  470.     /* Read in orig unsorted list if adding USER entries */
  471.     if (portion == USER) {
  472.         if ((ret = rdbsl(pdev)) != OK) {
  473.             if (ret == INVALID)
  474.                 err(cruptbsl);
  475.             goto togo;
  476.         }
  477.     }
  478.                 
  479.     /* Append new entries to end of BSL */
  480.     end = bsl + (RENT + entries)*BPE;    /* end of BSL */
  481.     for (i = 0; i < toadd; i++) {
  482.         put3bytes((end + i*BPE), addbuf[i]);
  483.     }
  484.     
  485.     /* make BSL checks sum to magic number */
  486.     mkmagic();
  487.  
  488.     if (portion == USER && toadd == empty) {
  489.         ret = USRFULL;
  490.         goto togo;
  491.     }
  492.         
  493.     ret = toadd;
  494.     
  495. togo:
  496.     if (addbuf > 0) free(addbuf);            
  497.     return(ret);
  498. }
  499.  
  500.  
  501. /*
  502.  *  Mark bad sectors from the BSL to FATs of a partition.
  503.  *    Input:
  504.  *        ldev - logical device the FATs belong to.
  505.  *        fat0 - logical sector number of where FAT 0 starts.
  506.  *        fatsiz - size of FAT in sectors.
  507.  *        data - logical sector number of where data clusters start.
  508.  *        portion - part of BSL to mark from.
  509.  */
  510. bsl2fat(ldev, fat0, fatsiz, data, portion)
  511. int  ldev;    /* logical device number */
  512. SECTOR fat0;    /* starting sector number (logical) of FAT 0 */ 
  513. UWORD fatsiz;    /* FAT size */
  514. SECTOR data;    /* starting sector number (logical) of data clusters */
  515. int portion;    /* part of BSL to mark from, VENDOR or MEDIA */
  516. {
  517.     long nument(), entries;    /* num entries in the list to be considered */
  518.     long i, end;        /* indices to the list to be considered */
  519.     long get3bytes();
  520.     SECTOR badsect;        /* a bad sector in the list */
  521.     SECTOR pstart;        /* phys sector num where partition starts */
  522.     SECTOR pdata;        /* phys sector num where data block starts */
  523.     SECTOR pend;        /* phys sector num where data block ends */
  524.     SECTOR logstart(), logend();
  525.     int nbad;
  526.     
  527.     nbad = 0;            /* assume none to be marked */
  528.     pstart = logstart(ldev);    /* find where partition starts */
  529.     pdata = pstart + data;    /* find where data block starts */
  530.     pend = logend(ldev);    /* find where data block ends */    
  531.     entries = nument(portion);    /* find num entries in given portion */
  532.     sortbsl(entries);        /* sort given portion of BSL */
  533.     
  534.     end = (RENT + entries) * BPE;
  535.     
  536.     /* Store vendor bad sectors of the logical device in badbuf */
  537.     for (i = BPE*RENT; i < end; i += BPE) {
  538.         if ((badsect = get3bytes(bsl+i)) > pend)
  539.             break;
  540.             
  541.         if (badsect >= pdata) {
  542.             badbuf[nbad++] = badsect;
  543.             
  544.             /* if badbuf overflows, mark what we have so far in the FAT */
  545.             if (nbad == WARNBADSECTS) {
  546.                 if (fixbadcls(ldev, fat0, fatsiz, data, nbad) < 0) {
  547.                     return ERROR;
  548.                 }
  549.                 nbad = 0;    /* reinit num bad sectors in partition to 0 */
  550.             }
  551.         }
  552.     }
  553.     
  554.     /* Bad sectors in partition not marked in FAT yet */
  555.     if (nbad) {
  556.         if (fixbadcls(ldev, fat0, fatsiz, data, nbad) < 0) {
  557.             return ERROR;
  558.         }
  559.     }
  560.     
  561.     return OK;
  562. }
  563.  
  564.  
  565. /*
  566.  *  Count number of bad sectors on a logical drive recorded in BSL.
  567.  *    Input:
  568.  *        ldev - logical drive to be considered.
  569.  *    Return:
  570.  *        nbad - number of bad sectors found.
  571.  */
  572. long
  573. cntbad(ldev)
  574. int  ldev;    /* logical drive number */
  575. {
  576.     SECTOR pstart, pend;    /* phys starting and ending block of ldev */
  577.     extern SECTOR logstart(), logend();
  578.     long nbad=0L;        /* num bad sectors on ldev */
  579.     long entries, nument(), bslend;
  580.     long curr, get3bytes();
  581.     int done, i;
  582.     
  583.     pstart = logstart(ldev);    /* starting block # of partition */
  584.     pend = logend(ldev);    /* ending block # of partition */
  585.     entries = nument(MEDIA);    /* num entries in BSL */
  586.     sortbsl(entries);        /* sort BSL */
  587.     
  588.     done = 0;
  589.     bslend = (RENT+entries) * BPE;
  590.     for (i = RENT*BPE; (!done) && (i < bslend); i += BPE) {
  591.         curr = get3bytes(bsl+i);  /* get next entry in BSL */
  592.         if (curr < pstart)      /* not within logical drive's range yet */
  593.             continue;
  594.         if (curr <= pend)      /* within logical drive's range */
  595.             nbad++;
  596.         else done = 1;          /* pass logical drive's range */
  597.     }
  598.     return (nbad);
  599. }
  600.  
  601.  
  602. /*
  603.  *  Put a word into memory in 68000 format.
  604.  *    Input:
  605.  *        p - pointer to memory.
  606.  *        i - word to be put.
  607.  */
  608. putword(p, i)
  609. BYTE *p;
  610. UWORD i;
  611. {
  612.     *p = i >> 8;
  613.     *(p+1) = i;
  614. }
  615.  
  616.  
  617. /*
  618.  *  Get a 68000 format word from memory.
  619.  *    Input:
  620.  *        p - pointer to memory.
  621.  *    Return:
  622.  *        i - word read from memory.
  623.  */        
  624. getword(p)
  625. BYTE *p;
  626. {
  627.     UWORD i=0x00ff, j=0x00ff;
  628.     
  629.     i &= *p;        /* first byte */
  630.     i <<= 8;
  631.     j &= *(p+1);    /* second byte */
  632.     i |= j;
  633.     return (i);
  634. }
  635.  
  636.  
  637. /*
  638.  *  Put 3 bytes (68000 format) into memory.
  639.  *    Input:
  640.  *        p - pointer to memory.
  641.  *        l - long which contains the 3 bytes at the low-bit end.
  642.  */
  643. put3bytes(p, l)
  644. BYTE *p;
  645. long l;
  646. {
  647.     *p = l >> 16;
  648.     *(p+1) = l >> 8;
  649.     *(p+2) = l;
  650. }    
  651.  
  652.  
  653. /*
  654.  *  Get 3 bytes (68000 format) from memory.
  655.  *    Input:
  656.  *        p - pointer to memory.
  657.  *    Return:
  658.  *        l - a long which contains the 3 bytes read in last 3 bytes.
  659.  */
  660. long
  661. get3bytes(p)
  662. BYTE *p;
  663. {
  664.     long  k=0x000000ff, l=0x000000ff;
  665.     
  666.     l &= *p;        /* first byte */
  667.     l <<= 16;
  668.     k &= *(p+1);    /* second byte */
  669.     k <<= 8;
  670.     l |= k;
  671.     k = 0x000000ff;
  672.     k &= *(p+2);    /* third byte */
  673.     l |= k;
  674.     return (l);
  675. }
  676.  
  677.  
  678.  
  679. /*
  680.  *  Get 4 bytes (68000 format) from memory.
  681.  *    Input:
  682.  *        p - pointer to memory.
  683.  *    Return:
  684.  *        l - a long which contains the 3 bytes read in last 3 bytes.
  685.  */
  686. long
  687. get4bytes(p)
  688. BYTE *p;
  689. {
  690.     long  k=0x000000ff, l=0x000000ff;
  691.     
  692.     l &= *p;        /* first byte */
  693.     l <<= 32;
  694.     k &= *(p+1);    /* second byte */
  695.     k <<= 16;
  696.     l |= k;
  697.     k = 0x000000ff;
  698.     k &= *(p+2);    /* third byte */
  699.     k <<= 8;
  700.     l |= k;
  701.     k = 0x000000ff;
  702.     k &= *(p+3);    /* Fourth byte */
  703.     l |= k;
  704.     return (l);
  705. }
  706.  
  707. /*
  708.  * Fixup bad sector entries in the FATs;
  709.  * suboptimal, since a FAT sector is read and two are
  710.  * written for EACH bad sector, even if there is
  711.  * more than one bad entry in a given FAT sector.
  712.  *
  713.  *
  714.  */
  715. fixbadcls(ldev, fat0, fatsiz, data, nbad)
  716. int ldev;        /* logical device */
  717. SECTOR fat0, data;
  718. UWORD fatsiz;
  719. int nbad;
  720. {
  721.     long numcl;
  722.     UWORD clno, nxtcl;
  723.     int i;
  724.     UWORD *buf;
  725.     SECTOR fat1;    /* physical starting sector# of 2nd FAT */
  726.     SECTOR pstart;    /* physical starting sector# of partition */
  727.     SECTOR badsect;    /* current bad sector */
  728.     extern SECTOR logstart();
  729.     extern LOGMAP logmap[];
  730.     int did=0, nmarked, ret, spc;
  731.     
  732.     
  733.     if((buf = (UWORD *)Malloc((long)fatsiz << 9)) <= 0)
  734.         return err(nomemory);
  735.     pstart = logstart(ldev);
  736.  
  737.     spc = 2*ratio;                    /* No, 2 spc */
  738.     numcl = (logmap[ldev-'C'].lm_siz - data) / spc;
  739.     fat1 = fat0 + fatsiz;
  740.             
  741.     if ((ret = rdsects(ldev, fatsiz, (char *)buf, fat0)) != 0) {
  742.         if (tsterr(ret) != OK)
  743.         err(fatread);
  744.     ret = ERROR;
  745.     goto fixend;
  746.     }
  747.     nmarked = 0;
  748.     for (i = 0; i < nbad; ++i) {
  749.     badsect = badbuf[i] - pstart;
  750.     if ((clno = (badsect - data)/spc) >= numcl)
  751.         continue;
  752.             
  753.        /* find out the next cluster number */
  754.        gw((UWORD *)(buf+clno+2), &nxtcl);
  755.             
  756.     /* Nope, ah ha, just mark it bad */
  757.     *(buf+clno+2) = 0xf7ff;    /* 0xfff7 in 8086-land */
  758.     nmarked++;
  759.  
  760.     /* write FAT0 and FAT1 */
  761.     if ((ret = wrsects(ldev, fatsiz, (char *)buf, fat0)) != 0 ||
  762.         (ret = wrsects(ldev, fatsiz, (char *)buf, fat1)) != 0)
  763.     {
  764.         if (tsterr(ret) != OK)
  765.             err(fatwrite);
  766.         ret = ERROR;
  767.         goto fixend;
  768.     }
  769.     }
  770.     ret = nmarked;
  771. fixend:
  772.     Mfree((long)buf);
  773.     return ret;
  774. }
  775.  
  776.